package com.atguigu.demojuc.chap01;

import java.util.concurrent.TimeUnit;

class Phone {

    /*情况一：start*/
    /*public synchronized void sendSms() {
        System.out.println(Thread.currentThread().getName()+",sendSms");
    }

    public synchronized void sendEmail() {
        System.out.println(Thread.currentThread().getName()+",sendEmail");
    }*/
    /*情况一：end*/

    /*情况二：start 停4秒在短信方法内，先打印短信还是邮件*/
    /*public synchronized void sendSms() {
        try {
          //Thread.sleep(4000);
           TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
       }
        System.out.println(Thread.currentThread().getName()+",sendSms");
    }*/

    /*public synchronized void sendEmail() {
        System.out.println(Thread.currentThread().getName()+",sendEmail");
    }*/
    /*情况一：end*/

    /*情况三：先访问短信（普通同步方法+睡眠），再访问hello方法（普通方法），是先打短信还是hello*/
    /*public synchronized void sendSms() {
        try {
            //Thread.sleep(4000);
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + ",sendSms");
    }

    public void hello() {
       System.out.println(Thread.currentThread().getName() + ",hello");
    }*/
    /*情况三：end*/


    /*情况四：start 现在有两部手机，第一部发短信，第二部发邮件，先打印短信还是邮件*/
    /*public synchronized void sendSms() {
        try {
            //Thread.sleep(4000);
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + ",sendSms");
    }

    public synchronized void sendEmail() {
        System.out.println(Thread.currentThread().getName() + ",sendEmail");
    }*/
    /*情况四：end*/

    /*情况五：两个静态同步方法，1部手机，先打印短信还是邮件*/
    /*public static synchronized void sendSms() {
        try {
            //Thread.sleep(4000);
           TimeUnit.SECONDS.sleep(4);
       } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + ",sendSms");
    }

    public static synchronized void sendEmail() {
        System.out.println(Thread.currentThread().getName() + ",sendEmail");
    }*/
    /*情况五：end*/

    /*情况六：两个静态同步方法，2部手机，先打印短信还是邮件*/
    /*public static synchronized void sendSms() {
        try {
            //Thread.sleep(4000);
           TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + ",sendSms");
    }

    public static synchronized void sendEmail() {
        System.out.println(Thread.currentThread().getName() + ",sendEmail");
    }*/
    /*情况六：end*/

    /*情况七：1个静态同步方法，一个普通同步方法，1部手机*/
    /*public static synchronized void sendSms() {
        try {
            //Thread.sleep(4000);
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + ",sendSms");
    }

    public synchronized void sendEmail() {
        System.out.println(Thread.currentThread().getName() + ",sendEmail");
    }*/
    /*情况七：end*/


    /*情况8：1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件*/
    public static synchronized void sendSms() {
        try {
            //Thread.sleep(4000);
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + ",sendSms");
    }

    public synchronized void sendEmail() {
        System.out.println(Thread.currentThread().getName() + ",sendEmail");
    }
    /*情况8：end*/

}


public class Lock8 {

    public static void main(String[] args) {
        //情况一：先访问短信，再访问邮件  结论：先短信再邮件
        //Phone phone = new Phone();
        //new Thread(()->{
        //    phone.sendSms();
        //}, "A").start();
        //
        //new Thread(()->{
        //    phone.sendEmail();
        //}, "B").start();

        //情况二：停4秒在短信方法内，先打印短信还是邮件  结论：先短信再邮件 原因：跟1一样两个线程使用是同一把锁:锁phone对象
        //Phone phone = new Phone();
        //new Thread(() -> {
        //    phone.sendSms();
        //}, "A").start();
        //
        //new Thread(() -> {
        //    phone.sendEmail();
        //}, "B").start();

        //情况三：先访问短信，再访问hello方法，是先打短信还是hello  结论：先hello,睡眠4秒后再短信 原因：线程一使用phone对象作为锁 线程二没有锁
        //Phone phone = new Phone();
        //new Thread(()->{
        //    //普通同步方法
        //    phone.sendSms();
        //}, "A").start();
        //
        //new Thread(()->{
        //    //普通方法
        //    phone.hello();
        //}, "B").start();


        //情况四：现在有两部手机，第一部发短信，第二部发邮件，先打印短信还是邮件
        //分析：线程A，B分别持有自己锁（phone实例对象） 结论：先邮件 睡眠4秒后 才短信
        //Phone phone1 = new Phone();
        //Phone phone2 = new Phone();
        //
        //new Thread(() -> {
        //    phone1.sendSms();
        //}, "A").start();
        //
        //
        //new Thread(() -> {
        //    phone2.sendEmail();
        //}, "B").start();

        //情况五：两个静态同步方法，1部手机，先打印短信还是邮件
        //分析：静态同步方法，锁变成Class类对象，是一把锁  结果：先睡眠4秒 再发送短信 最后执行发邮件
        //Phone phone = new Phone();
        //new Thread(() -> {
        //    phone.sendSms();
        //}, "A").start();
        //
        //
        //new Thread(() -> {
        //    phone.sendEmail();
        //}, "B").start();

        //情况六：两个静态同步方法，2部手机，先打印短信还是邮件
        //分析：静态同步方法，锁变成Class类对象，是一把锁  结果：先睡眠4秒 再发送短信 最后执行发邮件
        //Phone phone1 = new Phone();
        //Phone phone2 = new Phone();
        //new Thread(() -> {
        //    phone1.sendSms();
        //}, "A").start();
        //
        //
        //new Thread(() -> {
        //    phone2.sendEmail();
        //}, "B").start();

        //情况七：1个静态同步方法，1个普通同步方法，1部手机，先打印短信还是邮件
        //分析：线程A获取到phone实例锁，线程B锁是Phone Class类对象 不是同一把锁 结论：先邮件  睡眠4秒后打印短信
        //Phone phone = new Phone();
        //new Thread(() -> {
        //    phone.sendSms();
        //}, "A").start();
        //
        //
        //new Thread(() -> {
        //    phone.sendEmail();
        //}, "B").start();

        //情况8：1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件
        //分析：线程A锁是Phone类对象，线程B锁是phone2实例对象 不是同一把锁 结果：结论：先邮件  睡眠4秒后打印短信
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> {
            phone1.sendSms();
        }, "A").start();


        new Thread(() -> {
            phone2.sendEmail();
        }, "B").start();
    }
}